/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package clusteranalyst2;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/**
 *
 * @author Administrator
 */
public class MathMethods {
 //将对象数组转换成数组（矩阵）
    public double[][] ListToMatrix(ArrayList list)
    {
        int rowLen=((double[])(list.get(0))).length;
        double [][] Matrix=new double[list.size()][rowLen];
        for(int i=0;i<list.size();i++)
        {
            double[] a=(double[])(list.get(i));
           // System.out.println(a.length);           
            for(int j=0;j<rowLen;j++)
            {
                Matrix[i][j]=a[j];
            }
        }
        return  Matrix;
    }

    public double[][] HmTOMatrix(HashMap hm)
    {
        int rowLen=((double[])(hm.get(1))).length;
        int i=0;
        double [][] Matrix=new double[hm.size()][rowLen];
        Set entry=hm.entrySet();
        Iterator it=entry.iterator();       
        while(it.hasNext())
        {
             Map.Entry me=(Map.Entry)it.next();
             double [] a=(double[])(me.getValue());
             for(int j=0;j<a.length;j++)
             {
                 Matrix[i][j]=a[j];               
             }
           i++;
        }
        return Matrix;
    }
    //一维数组求和
    public double Sum(double [] data)
    {
        double sum=0;
       for(int i=0;i<data.length;i++)
       {
           sum+=data[i];
       }
        return sum;
    }
    //得到一维数组的最大值
    public double Maximum(double[] data)
    {
        double Max=data[0];
        for(int i=1;i<data.length;i++)
        {
            if(data[i]>Max)
            {
                Max=data[i];
            }
        }
        return Max;
    }
//得到一维数组的最小值
     public double Minimum(double[] data)
    {
        double Min=data[0];
        for(int i=1;i<data.length;i++)
        {
            if(data[i]<Min)
            {
                Min=data[i];
            }
        }
        return Min;
    }
//用于矩阵的转置
     public double[][] matriTranspose(double [][] FromMatrix)
     {
         double [][] ToMatrix=new double[FromMatrix[0].length][FromMatrix.length];
         for(int i=0;i<FromMatrix.length;i++)
         {
             for(int j=0;j<FromMatrix[0].length;j++)
             {
                 ToMatrix[j][i]=FromMatrix[i][j];
             }
         }
         return ToMatrix;
     }
////////////////////////////////////////一下为聚类运算的方法////////////////////////////////
    public int[] getMinIndex(double [][] matrix)
    {
        int rowIndex=0;
        int colIndex=0;
        
        double min=matrix[1][0];
        for(int i=0;i<matrix.length;i++)
        {
            for(int j=0;j<matrix[0].length;j++)
            {
                if(i!=j)
                {
                   if(matrix[i][j]<min)
                        {
                            min=matrix[i][j];
                            rowIndex=i;
                            colIndex=j;
                        }
                }
                else
                {
                    continue;
                }               
            }
        }
        int [] indexArray=new int []{rowIndex,colIndex};
        return indexArray;
    }
   //////////////////////////////////MatrixToHashMap///////////////////////////////////////
    public HashMap matrixToHashMap(double [][] matrix)
    {
        HashMap hm=new HashMap(GlobalVar.hmCapacity);
        Set keys=GlobalVar.keyList;
        Object[] keylist=keys.toArray();
        for(int i=0;i<matrix.length;i++)
        {
            double[] d=new double[matrix[0].length];
            for(int j=0;j<matrix[0].length;j++)
            {
                d[j]=matrix[i][j];
            }
            //hm.put(i+1, d);
            hm.put((Integer.parseInt(keylist[i].toString())), d);
        }
        return  hm;
    }

}


////////////////////////////////////////////////////
/*
 * HashMap hm=new HashMap();
        for(int i=0;i<matrix.length;i++)
        {
            double[] d=new double[matrix[0].length];
            for(int j=0;j<matrix[0].length;j++)
            {
                d[j]=matrix[i][j];
            }
            hm.put(i, d);
        }
        return  hm;
 */